﻿#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	
	Stack(const Stack& st)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);  //把st1的空间拷贝		
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		memcpy(_a, st._a, sizeof(STDataType) * st._top); //把st1的数据拷贝
		_top = st._top;
		_capacity = st._capacity;
	}
private:
		STDataType* _a;
		size_t _capacity;
		size_t _top;
	};


class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1) 
	{
		_year = year;
		_month = month;
		_day = day;

	}

	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

	
private:
	int _year;
	int _month;
	int _day;

};
class MyQueue
	{
	public:
		
	private:
		Stack pushst;
		Stack popst;
	};


void func(Date d)
{

}
Date f()
{
	Date ret;
	//...
	return ret;
}

int main()
{
	//Date d1(2024, 9, 2);
	//
	//// 这⾥可以完成拷⻉，但是不是拷⻉构造，只是⼀个普通的构造
	//Date d2(&d1);
	//d1.Print();
	//d2.Print();
	//
	////这样写才是拷⻉构造，通过同类型的对象初始化构造，⽽不是指针
	//Date d3(d1);
	//d2.Print();
	//
	//// 也可以这样写，这⾥也是拷⻉构造
	//Date d4 = d1;
	//d2.Print();
	//
	//// f返回了⼀个局部对象tmp的引⽤作为返回值
	//// f函数结束，tmp对象就销毁了，相当于了⼀个野引⽤
	//Date ret = f();
	//ret.Print();

	MyQueue m1;
	MyQueue m2(m1);

	return 0;
}
	




//// ⽤最新加了构造和析构的C++版本Stack实现
//bool isValid(const char* s) {
//	Stack st;
//	while (*s)
//	{
//		if (*s == '[' || *s == '(' || *s == '{')
//		{
//			st.Push(*s);
//		}
//		else
//		{
//			// 右括号⽐左括号多，数量匹配问题
//			if (st.Empty())
//			{
//				return false;
//			}
//			// 栈⾥⾯取左括号
//			char top = st.Top();
//			st.Pop();
//			// 顺序不匹配
//			if ((*s == ']' && top != '[')
//				|| (*s == '}' && top != '{')
//				|| (*s == ')' && top != '('))
//			{
//				return false;
//			}
//		}
//		++s;
//	}
//	// 栈为空，返回真，说明数量都匹配 左括号多，右括号少匹配问题
//	return st.Empty();
//}

//typedef int STDataType;
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//	// ...
//
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//private:
//	STDataType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//// 两个Stack实现队列
//class MyQueue
//{
//public:
//	//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
//	//编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
//	// 显⽰写析构，也会⾃动调⽤Stack的析构
//	/*~MyQueue()
//	{
//	}*/
//private:
//	Stack pushst;
//	Stack popst;
//};
//int main()
//{
//	Stack st;
//	MyQueue mq;
//	return 0;
//}

//class Date
//{
//public:
//	// 1.⽆参构造函数
//	Date()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}
//	// 2.带参构造函数
//	/*Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}*/
//	 //3.全缺省构造函数
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//	_year = year;
//	_month = month;
//	_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	
//	
//	Date d3();
//	// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法区分这⾥是函数声明还是实例化对象
//	// warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)
//	
//	return 0;
//}